home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 October: Mac OS SDK / Dev.CD Oct 97 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Universal / Interfaces / AIncludes / Slots.a < prev    next >
Encoding:
Text File  |  1997-08-12  |  26.3 KB  |  1,015 lines  |  [TEXT/MPS ]
  1. ;
  2. ;    File:        Slots.a
  3. ;
  4. ;    Contains:    Slot Manager Interfaces.
  5. ;
  6. ;    Version:    Technology:    System 7.5
  7. ;                Release:    Universal Interfaces 3.0.1
  8. ;
  9. ;    Copyright:    © 1986-1993, 1995-1997 by Apple Computer, Inc., all rights reserved
  10. ;
  11. ;    Bugs?:        Please include the the file and version information (from above) with
  12. ;                the problem description.  Developers belonging to one of the Apple
  13. ;                developer programs can submit bug reports to:
  14. ;
  15. ;                    devsupport@apple.com
  16. ;
  17. ;
  18.     IF &TYPE('__SLOTS__') = 'UNDEFINED' THEN
  19. __SLOTS__ SET 1
  20.  
  21.     IF &TYPE('__TYPES__') = 'UNDEFINED' THEN
  22.     include 'Types.a'
  23.     ENDIF
  24.     IF &TYPE('__EVENTS__') = 'UNDEFINED' THEN
  25.     include 'Events.a'
  26.     ENDIF
  27.     IF &TYPE('__FILES__') = 'UNDEFINED' THEN
  28.     include 'Files.a'
  29.     ENDIF
  30.  
  31.  
  32. fDontUse                        EQU        0                    ;old slotmgr put fcardIsChanged here
  33. fCardIsChanged                    EQU        1                    ;card is Changed field in StatusFlags field of sInfoArray
  34. fTempEnabled                    EQU        2                    ;slot is temporarily enabled
  35. fCkForNext                        EQU        0                    ;check for NEXT sRsrc in SRT            (SearchSRT)
  36. fCkReserved                        EQU        1                    ;check reserved field for zero         (ReadPBSize)
  37. fWarmStart                        EQU        2                    ;warm start, else cold start            (PrimaryInit)
  38. fClear                            EQU        3                    ;clear the memory                        (sNewPtr)
  39. fSys                            EQU        4                    ;alloc  on system heap                 (sNewPtr)
  40. fConsecBytes                    EQU        5                    ;calc step value for consecutive bytes (CalcStep)
  41.  
  42. stateNil                        EQU        0                    ;State
  43. stateSDMInit                    EQU        1                    ;:Slot declaration manager Init
  44. statePRAMInit                    EQU        2                    ;:sPRAM record init
  45. statePInit                        EQU        3                    ;:Primary init
  46. stateSInit                        EQU        4                    ;:Secondary init
  47.  
  48.                                                             ; flags for spParamData 
  49. fall                            EQU        0                    ; bit 0: set=search enabled/disabled sRsrc's 
  50. foneslot                        EQU        1                    ;    1: set=search sRsrc's in given slot only 
  51. fnext                            EQU        2                    ;    2: set=search for next sRsrc 
  52.  
  53.                                                             ; Misc masks 
  54. catMask                            EQU        $08                    ; sets spCategory field of spTBMask (bit 3) 
  55. cTypeMask                        EQU        $04                    ; sets spCType    field of spTBMask (bit 2) 
  56. drvrSWMask                        EQU        $02                    ; sets spDrvrSW   field of spTBMask (bit 1) 
  57. drvrHWMask                        EQU        $01                    ; sets spDrvrHW      field of spTBMask (bit 0) 
  58. SlotIntQElement            RECORD 0
  59. sqLink                     ds.l    1                ; offset: $0 (0)        ; ptr to next element
  60. sqType                     ds.w    1                ; offset: $4 (4)        ; queue type ID for validity
  61. sqPrio                     ds.w    1                ; offset: $6 (6)        ; priority
  62. sqAddr                     ds.l    1                ; offset: $8 (8)        ; interrupt service routine
  63. sqParm                     ds.l    1                ; offset: $C (12)        ; optional A1 parameter
  64. sizeof                     EQU *                    ; size:   $10 (16)
  65.                         ENDR
  66. ; typedef struct SlotIntQElement *        SQElemPtr
  67.  
  68. SpBlock                    RECORD 0
  69. spResult                 ds.l    1                ; offset: $0 (0)        ; FUNCTION Result
  70. spsPointer                 ds.l    1                ; offset: $4 (4)        ; structure pointer
  71. spSize                     ds.l    1                ; offset: $8 (8)        ; size of structure
  72. spOffsetData             ds.l    1                ; offset: $C (12)        ; offset/data field used by sOffsetData
  73. spIOFileName             ds.l    1                ; offset: $10 (16)        ; ptr to IOFile name for sDisDrvrName
  74. spsExecPBlk                 ds.l    1                ; offset: $14 (20)        ; pointer to sExec parameter block.
  75. spParamData                 ds.l    1                ; offset: $18 (24)        ; misc parameter data (formerly spStackPtr).
  76. spMisc                     ds.l    1                ; offset: $1C (28)        ; misc field for SDM.
  77. spReserved                 ds.l    1                ; offset: $20 (32)        ; reserved for future expansion
  78. spIOReserved             ds.w    1                ; offset: $24 (36)        ; Reserved field of Slot Resource Table
  79. spRefNum                 ds.w    1                ; offset: $26 (38)        ; RefNum
  80. spCategory                 ds.w    1                ; offset: $28 (40)        ; sType: Category
  81. spCType                     ds.w    1                ; offset: $2A (42)        ; Type
  82. spDrvrSW                 ds.w    1                ; offset: $2C (44)        ; DrvrSW
  83. spDrvrHW                 ds.w    1                ; offset: $2E (46)        ; DrvrHW
  84. spTBMask                 ds.b    1                ; offset: $30 (48)        ; type bit mask bits 0..3 mask words 0..3
  85. spSlot                     ds.b    1                ; offset: $31 (49)        ; slot number
  86. spID                     ds.b    1                ; offset: $32 (50)        ; structure ID
  87. spExtDev                 ds.b    1                ; offset: $33 (51)        ; ID of the external device
  88. spHwDev                     ds.b    1                ; offset: $34 (52)        ; Id of the hardware device.
  89. spByteLanes                 ds.b    1                ; offset: $35 (53)        ; bytelanes from card ROM format block
  90. spFlags                     ds.b    1                ; offset: $36 (54)        ; standard flags
  91. spKey                     ds.b    1                ; offset: $37 (55)        ; Internal use only
  92. sizeof                     EQU *                    ; size:   $38 (56)
  93.                         ENDR
  94. ; typedef struct SpBlock *                SpBlockPtr
  95.  
  96. SInfoRecord                RECORD 0
  97. siDirPtr                 ds.l    1                ; offset: $0 (0)        ; Pointer to directory
  98. siInitStatusA             ds.w    1                ; offset: $4 (4)        ; initialization E
  99. siInitStatusV             ds.w    1                ; offset: $6 (6)        ; status returned by vendor init code
  100. siState                     ds.b    1                ; offset: $8 (8)        ; initialization state
  101. siCPUByteLanes             ds.b    1                ; offset: $9 (9)        ; 0=[d0..d7] 1=[d8..d15]
  102. siTopOfROM                 ds.b    1                ; offset: $A (10)        ; Top of ROM= $FssFFFFx: x is TopOfROM
  103. siStatusFlags             ds.b    1                ; offset: $B (11)        ; bit 0 - card is changed
  104. siTOConst                 ds.w    1                ; offset: $C (12)        ; Time Out C for BusErr
  105. siReserved                 ds.b    2                ; offset: $E (14)        ; reserved
  106. siROMAddr                 ds.l    1                ; offset: $10 (16)        ;  addr of top of ROM 
  107. siSlot                     ds.b    1                ; offset: $14 (20)        ;  slot number 
  108. siPadding                 ds.b    3                ; offset: $15 (21)        ;  reserved 
  109. sizeof                     EQU *                    ; size:   $18 (24)
  110.                         ENDR
  111. ; typedef struct SInfoRecord *            SInfoRecPtr
  112.  
  113. SDMRecord                RECORD 0
  114. sdBEVSave                 ds.l    1                ; offset: $0 (0)        ; Save old BusErr vector
  115. sdBusErrProc             ds.l    1                ; offset: $4 (4)        ; Go here to determine if it is a BusErr
  116. sdErrorEntry             ds.l    1                ; offset: $8 (8)        ; Go here if BusErrProc finds real BusErr
  117. sdReserved                 ds.l    1                ; offset: $C (12)        ; Reserved
  118. sizeof                     EQU *                    ; size:   $10 (16)
  119.                         ENDR
  120. FHeaderRec                RECORD 0
  121. fhDirOffset                 ds.l    1                ; offset: $0 (0)        ; offset to directory
  122. fhLength                 ds.l    1                ; offset: $4 (4)        ; length of ROM
  123. fhCRC                     ds.l    1                ; offset: $8 (8)        ; CRC
  124. fhROMRev                 ds.b    1                ; offset: $C (12)        ; revision of ROM
  125. fhFormat                 ds.b    1                ; offset: $D (13)        ; format - 2
  126. fhTstPat                 ds.l    1                ; offset: $E (14)        ; test pattern
  127. fhReserved                 ds.b    1                ; offset: $12 (18)        ; reserved
  128. fhByteLanes                 ds.b    1                ; offset: $13 (19)        ; ByteLanes
  129. sizeof                     EQU *                    ; size:   $14 (20)
  130.                         ENDR
  131. ; typedef struct FHeaderRec *            FHeaderRecPtr
  132.  
  133. OffsetToDir        EQU            FHeaderRec.fhDirOffset-FHeaderRec.sizeof+1    ; offset to dir ptr    <1.8>
  134.  
  135. ;   
  136. ;       Extended Format header block  -  extended declaration ROM format header for super sRsrc directories.    <H2><SM0>
  137. ;   
  138.  
  139.  
  140.  
  141. XFHeaderRec                RECORD 0
  142. fhXSuperInit             ds.l    1                ; offset: $0 (0)        ; Offset to SuperInit SExecBlock    <fhFormat,offset>
  143. fhXSDirOffset             ds.l    1                ; offset: $4 (4)        ; Offset to SuperDirectory            <$FE,offset>
  144. fhXEOL                     ds.l    1                ; offset: $8 (8)        ; Psuedo end-of-list                <$FF,nil>
  145. fhXSTstPat                 ds.l    1                ; offset: $C (12)        ; TestPattern
  146. fhXDirOffset             ds.l    1                ; offset: $10 (16)        ; Offset to (minimal) directory
  147. fhXLength                 ds.l    1                ; offset: $14 (20)        ; Length of ROM
  148. fhXCRC                     ds.l    1                ; offset: $18 (24)        ; CRC
  149. fhXROMRev                 ds.b    1                ; offset: $1C (28)        ; Revision of ROM
  150. fhXFormat                 ds.b    1                ; offset: $1D (29)        ; Format-2
  151. fhXTstPat                 ds.l    1                ; offset: $1E (30)        ; TestPattern
  152. fhXReserved                 ds.b    1                ; offset: $22 (34)        ; Reserved
  153. fhXByteLanes             ds.b    1                ; offset: $23 (35)        ; ByteLanes
  154. sizeof                     EQU *                    ; size:   $24 (36)
  155.                         ENDR
  156. ; typedef struct XFHeaderRec *            XFHeaderRecPtr
  157.  
  158. XFHdrExtraSize    Equ            XFHeaderRec.sizeof-FHeaderRec.sizeof        ; (extended - standard) delta
  159. XOffsetToDir    Equ            XFHeaderRec.fhXSDirOffset-XFHeaderRec.sizeof+1    ; offset to super dir ptr
  160. XOffsetToSInit    Equ            XFHeaderRec.fhXSuperInit-XFHeaderRec.sizeof+1    ; offset to super dir ptr
  161. SEBlock                    RECORD 0
  162. seSlot                     ds.b    1                ; offset: $0 (0)        ; Slot number.
  163. sesRsrcId                 ds.b    1                ; offset: $1 (1)        ; sResource Id.
  164. seStatus                 ds.w    1                ; offset: $2 (2)        ; Status of code executed by sExec.
  165. seFlags                     ds.b    1                ; offset: $4 (4)        ; Flags
  166. seFiller0                 ds.b    1                ; offset: $5 (5)        ; Filler, must be SignedByte to align on odd boundry
  167. seFiller1                 ds.b    1                ; offset: $6 (6)        ; Filler
  168. seFiller2                 ds.b    1                ; offset: $7 (7)        ; Filler
  169. seResult                 ds.l    1                ; offset: $8 (8)        ; Result of sLoad.
  170. seIOFileName             ds.l    1                ; offset: $C (12)        ; Pointer to IOFile name.
  171. seDevice                 ds.b    1                ; offset: $10 (16)        ; Which device to read from.
  172. sePartition                 ds.b    1                ; offset: $11 (17)        ; The partition.
  173. seOSType                 ds.b    1                ; offset: $12 (18)        ; Type of OS.
  174. seReserved                 ds.b    1                ; offset: $13 (19)        ; Reserved field.
  175. seRefNum                 ds.b    1                ; offset: $14 (20)        ; RefNum of the driver.
  176. seNumDevices             ds.b    1                ; offset: $15 (21)        ;  Number of devices to load.
  177. seBootState                 ds.b    1                ; offset: $16 (22)        ; State of StartBoot code.
  178. filler                     ds.b    1                ; offset: $17 (23)
  179. sizeof                     EQU *                    ; size:   $18 (24)
  180.                         ENDR
  181. ;   Principle  
  182. ;
  183. ; pascal OSErr SReadByte(SpBlockPtr spBlkPtr)
  184. ;
  185.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  186.         ; parameters:
  187.         ;    spBlkPtr        => A0
  188.         ; returns:
  189.         ;    OSErr           <= D0
  190.         Macro
  191.         _SReadByte
  192.             moveq               #0,D0
  193.             dc.w                $A06E
  194.         EndM
  195.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  196.         IMPORT_CFM_FUNCTION SReadByte
  197.     ENDIF
  198.  
  199. ;
  200. ; pascal OSErr SReadWord(SpBlockPtr spBlkPtr)
  201. ;
  202.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  203.         ; parameters:
  204.         ;    spBlkPtr        => A0
  205.         ; returns:
  206.         ;    OSErr           <= D0
  207.         Macro
  208.         _SReadWord
  209.             moveq               #1,D0
  210.             dc.w                $A06E
  211.         EndM
  212.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  213.         IMPORT_CFM_FUNCTION SReadWord
  214.     ENDIF
  215.  
  216. ;
  217. ; pascal OSErr SReadLong(SpBlockPtr spBlkPtr)
  218. ;
  219.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  220.         ; parameters:
  221.         ;    spBlkPtr        => A0
  222.         ; returns:
  223.         ;    OSErr           <= D0
  224.         Macro
  225.         _SReadLong
  226.             moveq               #2,D0
  227.             dc.w                $A06E
  228.         EndM
  229.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  230.         IMPORT_CFM_FUNCTION SReadLong
  231.     ENDIF
  232.  
  233. ;
  234. ; pascal OSErr SGetCString(SpBlockPtr spBlkPtr)
  235. ;
  236.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  237.         ; parameters:
  238.         ;    spBlkPtr        => A0
  239.         ; returns:
  240.         ;    OSErr           <= D0
  241.         Macro
  242.         _SGetCString
  243.             moveq               #3,D0
  244.             dc.w                $A06E
  245.         EndM
  246.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  247.         IMPORT_CFM_FUNCTION SGetCString
  248.     ENDIF
  249.  
  250. ;
  251. ; pascal OSErr SGetBlock(SpBlockPtr spBlkPtr)
  252. ;
  253.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  254.         ; parameters:
  255.         ;    spBlkPtr        => A0
  256.         ; returns:
  257.         ;    OSErr           <= D0
  258.         Macro
  259.         _SGetBlock
  260.             moveq               #5,D0
  261.             dc.w                $A06E
  262.         EndM
  263.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  264.         IMPORT_CFM_FUNCTION SGetBlock
  265.     ENDIF
  266.  
  267. ;
  268. ; pascal OSErr SFindStruct(SpBlockPtr spBlkPtr)
  269. ;
  270.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  271.         ; parameters:
  272.         ;    spBlkPtr        => A0
  273.         ; returns:
  274.         ;    OSErr           <= D0
  275.         Macro
  276.         _SFindStruct
  277.             moveq               #6,D0
  278.             dc.w                $A06E
  279.         EndM
  280.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  281.         IMPORT_CFM_FUNCTION SFindStruct
  282.     ENDIF
  283.  
  284. ;
  285. ; pascal OSErr SReadStruct(SpBlockPtr spBlkPtr)
  286. ;
  287.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  288.         ; parameters:
  289.         ;    spBlkPtr        => A0
  290.         ; returns:
  291.         ;    OSErr           <= D0
  292.         Macro
  293.         _SReadStruct
  294.             moveq               #7,D0
  295.             dc.w                $A06E
  296.         EndM
  297.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  298.         IMPORT_CFM_FUNCTION SReadStruct
  299.     ENDIF
  300.  
  301. ;   Special  
  302. ;
  303. ; pascal OSErr SReadInfo(SpBlockPtr spBlkPtr)
  304. ;
  305.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  306.         ; parameters:
  307.         ;    spBlkPtr        => A0
  308.         ; returns:
  309.         ;    OSErr           <= D0
  310.         Macro
  311.         _SReadInfo
  312.             moveq               #16,D0
  313.             dc.w                $A06E
  314.         EndM
  315.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  316.         IMPORT_CFM_FUNCTION SReadInfo
  317.     ENDIF
  318.  
  319. ;
  320. ; pascal OSErr SReadPRAMRec(SpBlockPtr spBlkPtr)
  321. ;
  322.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  323.         ; parameters:
  324.         ;    spBlkPtr        => A0
  325.         ; returns:
  326.         ;    OSErr           <= D0
  327.         Macro
  328.         _SReadPRAMRec
  329.             moveq               #17,D0
  330.             dc.w                $A06E
  331.         EndM
  332.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  333.         IMPORT_CFM_FUNCTION SReadPRAMRec
  334.     ENDIF
  335.  
  336. ;
  337. ; pascal OSErr SPutPRAMRec(SpBlockPtr spBlkPtr)
  338. ;
  339.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  340.         ; parameters:
  341.         ;    spBlkPtr        => A0
  342.         ; returns:
  343.         ;    OSErr           <= D0
  344.         Macro
  345.         _SPutPRAMRec
  346.             moveq               #18,D0
  347.             dc.w                $A06E
  348.         EndM
  349.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  350.         IMPORT_CFM_FUNCTION SPutPRAMRec
  351.     ENDIF
  352.  
  353. ;
  354. ; pascal OSErr SReadFHeader(SpBlockPtr spBlkPtr)
  355. ;
  356.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  357.         ; parameters:
  358.         ;    spBlkPtr        => A0
  359.         ; returns:
  360.         ;    OSErr           <= D0
  361.         Macro
  362.         _SReadFHeader
  363.             moveq               #19,D0
  364.             dc.w                $A06E
  365.         EndM
  366.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  367.         IMPORT_CFM_FUNCTION SReadFHeader
  368.     ENDIF
  369.  
  370. ;
  371. ; pascal OSErr SNextSRsrc(SpBlockPtr spBlkPtr)
  372. ;
  373.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  374.         ; parameters:
  375.         ;    spBlkPtr        => A0
  376.         ; returns:
  377.         ;    OSErr           <= D0
  378.         Macro
  379.         _SNextSRsrc
  380.             moveq               #20,D0
  381.             dc.w                $A06E
  382.         EndM
  383.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  384.         IMPORT_CFM_FUNCTION SNextSRsrc
  385.     ENDIF
  386.  
  387. ;
  388. ; pascal OSErr SNextTypeSRsrc(SpBlockPtr spBlkPtr)
  389. ;
  390.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  391.         ; parameters:
  392.         ;    spBlkPtr        => A0
  393.         ; returns:
  394.         ;    OSErr           <= D0
  395.         Macro
  396.         _SNextTypeSRsrc
  397.             moveq               #21,D0
  398.             dc.w                $A06E
  399.         EndM
  400.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  401.         IMPORT_CFM_FUNCTION SNextTypeSRsrc
  402.     ENDIF
  403.  
  404. ;
  405. ; pascal OSErr SRsrcInfo(SpBlockPtr spBlkPtr)
  406. ;
  407.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  408.         ; parameters:
  409.         ;    spBlkPtr        => A0
  410.         ; returns:
  411.         ;    OSErr           <= D0
  412.         Macro
  413.         _SRsrcInfo
  414.             moveq               #22,D0
  415.             dc.w                $A06E
  416.         EndM
  417.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  418.         IMPORT_CFM_FUNCTION SRsrcInfo
  419.     ENDIF
  420.  
  421. ;
  422. ; pascal OSErr SDisposePtr(SpBlockPtr spBlkPtr)
  423. ;
  424.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  425.         ; parameters:
  426.         ;    spBlkPtr        => A0
  427.         ; returns:
  428.         ;    OSErr           <= D0
  429.         Macro
  430.         _SDisposePtr
  431.             moveq               #23,D0
  432.             dc.w                $A06E
  433.         EndM
  434.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  435.         IMPORT_CFM_FUNCTION SDisposePtr
  436.     ENDIF
  437.  
  438. ;
  439. ; pascal OSErr SCkCardStat(SpBlockPtr spBlkPtr)
  440. ;
  441.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  442.         ; parameters:
  443.         ;    spBlkPtr        => A0
  444.         ; returns:
  445.         ;    OSErr           <= D0
  446.         Macro
  447.         _SCkCardStat
  448.             moveq               #24,D0
  449.             dc.w                $A06E
  450.         EndM
  451.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  452.         IMPORT_CFM_FUNCTION SCkCardStat
  453.     ENDIF
  454.  
  455. ;
  456. ; pascal OSErr SReadDrvrName(SpBlockPtr spBlkPtr)
  457. ;
  458.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  459.         ; parameters:
  460.         ;    spBlkPtr        => A0
  461.         ; returns:
  462.         ;    OSErr           <= D0
  463.         Macro
  464.         _SReadDrvrName
  465.             moveq               #25,D0
  466.             dc.w                $A06E
  467.         EndM
  468.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  469.         IMPORT_CFM_FUNCTION SReadDrvrName
  470.     ENDIF
  471.  
  472. ;
  473. ; pascal OSErr SFindSRTRec(SpBlockPtr spBlkPtr)
  474. ;
  475.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  476.         ; parameters:
  477.         ;    spBlkPtr        => A0
  478.         ; returns:
  479.         ;    OSErr           <= D0
  480.         Macro
  481.         _SFindSRTRec
  482.             moveq               #26,D0
  483.             dc.w                $A06E
  484.         EndM
  485.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  486.         IMPORT_CFM_FUNCTION SFindSRTRec
  487.     ENDIF
  488.  
  489. ;
  490. ; pascal OSErr SFindDevBase(SpBlockPtr spBlkPtr)
  491. ;
  492.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  493.         ; parameters:
  494.         ;    spBlkPtr        => A0
  495.         ; returns:
  496.         ;    OSErr           <= D0
  497.         Macro
  498.         _SFindDevBase
  499.             moveq               #27,D0
  500.             dc.w                $A06E
  501.         EndM
  502.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  503.         IMPORT_CFM_FUNCTION SFindDevBase
  504.     ENDIF
  505.  
  506. ;
  507. ; pascal OSErr SFindBigDevBase(SpBlockPtr spBlkPtr)
  508. ;
  509.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  510.         ; parameters:
  511.         ;    spBlkPtr        => A0
  512.         ; returns:
  513.         ;    OSErr           <= D0
  514.         Macro
  515.         _SFindBigDevBase
  516.             moveq               #28,D0
  517.             dc.w                $A06E
  518.         EndM
  519.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  520.         IMPORT_CFM_FUNCTION SFindBigDevBase
  521.     ENDIF
  522.  
  523. ;   Advanced  
  524. ;
  525. ; pascal OSErr InitSDeclMgr(SpBlockPtr spBlkPtr)
  526. ;
  527.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  528.         ; parameters:
  529.         ;    spBlkPtr        => A0
  530.         ; returns:
  531.         ;    OSErr           <= D0
  532.         Macro
  533.         _InitSDeclMgr
  534.             moveq               #32,D0
  535.             dc.w                $A06E
  536.         EndM
  537.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  538.         IMPORT_CFM_FUNCTION InitSDeclMgr
  539.     ENDIF
  540.  
  541. ;
  542. ; pascal OSErr SPrimaryInit(SpBlockPtr spBlkPtr)
  543. ;
  544.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  545.         ; parameters:
  546.         ;    spBlkPtr        => A0
  547.         ; returns:
  548.         ;    OSErr           <= D0
  549.         Macro
  550.         _SPrimaryInit
  551.             moveq               #33,D0
  552.             dc.w                $A06E
  553.         EndM
  554.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  555.         IMPORT_CFM_FUNCTION SPrimaryInit
  556.     ENDIF
  557.  
  558. ;
  559. ; pascal OSErr SCardChanged(SpBlockPtr spBlkPtr)
  560. ;
  561.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  562.         ; parameters:
  563.         ;    spBlkPtr        => A0
  564.         ; returns:
  565.         ;    OSErr           <= D0
  566.         Macro
  567.         _SCardChanged
  568.             moveq               #34,D0
  569.             dc.w                $A06E
  570.         EndM
  571.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  572.         IMPORT_CFM_FUNCTION SCardChanged
  573.     ENDIF
  574.  
  575. ;
  576. ; pascal OSErr SExec(SpBlockPtr spBlkPtr)
  577. ;
  578.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  579.         ; parameters:
  580.         ;    spBlkPtr        => A0
  581.         ; returns:
  582.         ;    OSErr           <= D0
  583.         Macro
  584.         _SExec
  585.             moveq               #35,D0
  586.             dc.w                $A06E
  587.         EndM
  588.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  589.         IMPORT_CFM_FUNCTION SExec
  590.     ENDIF
  591.  
  592. ;
  593. ; pascal OSErr SOffsetData(SpBlockPtr spBlkPtr)
  594. ;
  595.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  596.         ; parameters:
  597.         ;    spBlkPtr        => A0
  598.         ; returns:
  599.         ;    OSErr           <= D0
  600.         Macro
  601.         _SOffsetData
  602.             moveq               #36,D0
  603.             dc.w                $A06E
  604.         EndM
  605.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  606.         IMPORT_CFM_FUNCTION SOffsetData
  607.     ENDIF
  608.  
  609. ;
  610. ; pascal OSErr SInitPRAMRecs(SpBlockPtr spBlkPtr)
  611. ;
  612.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  613.         ; parameters:
  614.         ;    spBlkPtr        => A0
  615.         ; returns:
  616.         ;    OSErr           <= D0
  617.         Macro
  618.         _SInitPRAMRecs
  619.             moveq               #37,D0
  620.             dc.w                $A06E
  621.         EndM
  622.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  623.         IMPORT_CFM_FUNCTION SInitPRAMRecs
  624.     ENDIF
  625.  
  626. ;
  627. ; pascal OSErr SReadPBSize(SpBlockPtr spBlkPtr)
  628. ;
  629.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  630.         ; parameters:
  631.         ;    spBlkPtr        => A0
  632.         ; returns:
  633.         ;    OSErr           <= D0
  634.         Macro
  635.         _SReadPBSize
  636.             moveq               #38,D0
  637.             dc.w                $A06E
  638.         EndM
  639.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  640.         IMPORT_CFM_FUNCTION SReadPBSize
  641.     ENDIF
  642.  
  643. ;
  644. ; pascal OSErr SCalcStep(SpBlockPtr spBlkPtr)
  645. ;
  646.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  647.         ; parameters:
  648.         ;    spBlkPtr        => A0
  649.         ; returns:
  650.         ;    OSErr           <= D0
  651.         Macro
  652.         _SCalcStep
  653.             moveq               #40,D0
  654.             dc.w                $A06E
  655.         EndM
  656.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  657.         IMPORT_CFM_FUNCTION SCalcStep
  658.     ENDIF
  659.  
  660. ;
  661. ; pascal OSErr SInitSRsrcTable(SpBlockPtr spBlkPtr)
  662. ;
  663.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  664.         ; parameters:
  665.         ;    spBlkPtr        => A0
  666.         ; returns:
  667.         ;    OSErr           <= D0
  668.         Macro
  669.         _SInitSRsrcTable
  670.             moveq               #41,D0
  671.             dc.w                $A06E
  672.         EndM
  673.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  674.         IMPORT_CFM_FUNCTION SInitSRsrcTable
  675.     ENDIF
  676.  
  677. ;
  678. ; pascal OSErr SSearchSRT(SpBlockPtr spBlkPtr)
  679. ;
  680.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  681.         ; parameters:
  682.         ;    spBlkPtr        => A0
  683.         ; returns:
  684.         ;    OSErr           <= D0
  685.         Macro
  686.         _SSearchSRT
  687.             moveq               #42,D0
  688.             dc.w                $A06E
  689.         EndM
  690.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  691.         IMPORT_CFM_FUNCTION SSearchSRT
  692.     ENDIF
  693.  
  694. ;
  695. ; pascal OSErr SUpdateSRT(SpBlockPtr spBlkPtr)
  696. ;
  697.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  698.         ; parameters:
  699.         ;    spBlkPtr        => A0
  700.         ; returns:
  701.         ;    OSErr           <= D0
  702.         Macro
  703.         _SUpdateSRT
  704.             moveq               #43,D0
  705.             dc.w                $A06E
  706.         EndM
  707.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  708.         IMPORT_CFM_FUNCTION SUpdateSRT
  709.     ENDIF
  710.  
  711. ;
  712. ; pascal OSErr SCalcSPointer(SpBlockPtr spBlkPtr)
  713. ;
  714.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  715.         ; parameters:
  716.         ;    spBlkPtr        => A0
  717.         ; returns:
  718.         ;    OSErr           <= D0
  719.         Macro
  720.         _SCalcSPointer
  721.             moveq               #44,D0
  722.             dc.w                $A06E
  723.         EndM
  724.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  725.         IMPORT_CFM_FUNCTION SCalcSPointer
  726.     ENDIF
  727.  
  728. ;
  729. ; pascal OSErr SGetDriver(SpBlockPtr spBlkPtr)
  730. ;
  731.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  732.         ; parameters:
  733.         ;    spBlkPtr        => A0
  734.         ; returns:
  735.         ;    OSErr           <= D0
  736.         Macro
  737.         _SGetDriver
  738.             moveq               #45,D0
  739.             dc.w                $A06E
  740.         EndM
  741.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  742.         IMPORT_CFM_FUNCTION SGetDriver
  743.     ENDIF
  744.  
  745. ;
  746. ; pascal OSErr SPtrToSlot(SpBlockPtr spBlkPtr)
  747. ;
  748.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  749.         ; parameters:
  750.         ;    spBlkPtr        => A0
  751.         ; returns:
  752.         ;    OSErr           <= D0
  753.         Macro
  754.         _SPtrToSlot
  755.             moveq               #46,D0
  756.             dc.w                $A06E
  757.         EndM
  758.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  759.         IMPORT_CFM_FUNCTION SPtrToSlot
  760.     ENDIF
  761.  
  762. ;
  763. ; pascal OSErr SFindSInfoRecPtr(SpBlockPtr spBlkPtr)
  764. ;
  765.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  766.         ; parameters:
  767.         ;    spBlkPtr        => A0
  768.         ; returns:
  769.         ;    OSErr           <= D0
  770.         Macro
  771.         _SFindSInfoRecPtr
  772.             moveq               #47,D0
  773.             dc.w                $A06E
  774.         EndM
  775.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  776.         IMPORT_CFM_FUNCTION SFindSInfoRecPtr
  777.     ENDIF
  778.  
  779. ;
  780. ; pascal OSErr SFindSRsrcPtr(SpBlockPtr spBlkPtr)
  781. ;
  782.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  783.         ; parameters:
  784.         ;    spBlkPtr        => A0
  785.         ; returns:
  786.         ;    OSErr           <= D0
  787.         Macro
  788.         _SFindSRsrcPtr
  789.             moveq               #48,D0
  790.             dc.w                $A06E
  791.         EndM
  792.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  793.         IMPORT_CFM_FUNCTION SFindSRsrcPtr
  794.     ENDIF
  795.  
  796. ;
  797. ; pascal OSErr SDeleteSRTRec(SpBlockPtr spBlkPtr)
  798. ;
  799.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  800.         ; parameters:
  801.         ;    spBlkPtr        => A0
  802.         ; returns:
  803.         ;    OSErr           <= D0
  804.         Macro
  805.         _SDeleteSRTRec
  806.             moveq               #49,D0
  807.             dc.w                $A06E
  808.         EndM
  809.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  810.         IMPORT_CFM_FUNCTION SDeleteSRTRec
  811.     ENDIF
  812.  
  813. ;
  814. ; pascal OSErr SSecondaryInit(SpBlockPtr spBlkPtr)
  815. ;
  816.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  817.         ; parameters:
  818.         ;    spBlkPtr        => A0
  819.         ; returns:
  820.         ;    OSErr           <= D0
  821.         Macro
  822.         _SSecondaryInit
  823.             moveq               #50,D0
  824.             dc.w                $A06E
  825.         EndM
  826.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  827.         IMPORT_CFM_FUNCTION SSecondaryInit
  828.     ENDIF
  829.  
  830. ;
  831. ; pascal OSErr SInitSlotPRAM(SpBlockPtr spBlkPtr)
  832. ;
  833.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  834.         ; parameters:
  835.         ;    spBlkPtr        => A0
  836.         ; returns:
  837.         ;    OSErr           <= D0
  838.         Macro
  839.         _SInitSlotPRAM
  840.             moveq               #51,D0
  841.             dc.w                $A06E
  842.         EndM
  843.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  844.         IMPORT_CFM_FUNCTION SInitSlotPRAM
  845.     ENDIF
  846.  
  847. ;
  848. ; pascal OSErr OpenSlot(ParmBlkPtr paramBlock, Boolean async)
  849. ;
  850.     IF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  851.         IMPORT_CFM_FUNCTION OpenSlot
  852.     ENDIF
  853.  
  854. ;
  855. ; pascal OSErr OpenSlotSync(ParmBlkPtr paramBlock)
  856. ;
  857.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  858.         ; parameters:
  859.         ;    paramBlock      => A0
  860.         ; returns:
  861.         ;    OSErr           <= D0
  862.         _OpenSlotSync:    OPWORD    $A200
  863.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  864.         IMPORT_CFM_FUNCTION OpenSlotSync
  865.     ENDIF
  866.  
  867. ;
  868. ; pascal OSErr OpenSlotAsync(ParmBlkPtr paramBlock)
  869. ;
  870.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  871.         ; parameters:
  872.         ;    paramBlock      => A0
  873.         ; returns:
  874.         ;    OSErr           <= D0
  875.         _OpenSlotAsync:    OPWORD    $A600
  876.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  877.         IMPORT_CFM_FUNCTION OpenSlotAsync
  878.     ENDIF
  879.  
  880. ;   Device Manager Slot Support  
  881. ;
  882. ; pascal OSErr SIntInstall(SQElemPtr sIntQElemPtr, short theSlot)
  883. ;
  884.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  885.         ; parameters:
  886.         ;    sIntQElemPtrtheSlot=> A0
  887.         ;    theSlot         => D0
  888.         ; returns:
  889.         ;    OSErr           <= D0
  890.         _SIntInstall:    OPWORD    $A075
  891.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  892.         IMPORT_CFM_FUNCTION SIntInstall
  893.     ENDIF
  894.  
  895. ;
  896. ; pascal OSErr SIntRemove(SQElemPtr sIntQElemPtr, short theSlot)
  897. ;
  898.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  899.         ; parameters:
  900.         ;    sIntQElemPtrtheSlot=> A0
  901.         ;    theSlot         => D0
  902.         ; returns:
  903.         ;    OSErr           <= D0
  904.         _SIntRemove:    OPWORD    $A076
  905.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  906.         IMPORT_CFM_FUNCTION SIntRemove
  907.     ENDIF
  908.  
  909. ;
  910. ; pascal OSErr SVersion(SpBlockPtr spBlkPtr)
  911. ;
  912.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  913.         ; parameters:
  914.         ;    spBlkPtr        => A0
  915.         ; returns:
  916.         ;    OSErr           <= D0
  917.         Macro
  918.         _SVersion
  919.             moveq               #8,D0
  920.             dc.w                $A06E
  921.         EndM
  922.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  923.         IMPORT_CFM_FUNCTION SVersion
  924.     ENDIF
  925.  
  926. ;
  927. ; pascal OSErr SetSRsrcState(SpBlockPtr spBlkPtr)
  928. ;
  929.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  930.         ; parameters:
  931.         ;    spBlkPtr        => A0
  932.         ; returns:
  933.         ;    OSErr           <= D0
  934.         Macro
  935.         _SetSRsrcState
  936.             moveq               #9,D0
  937.             dc.w                $A06E
  938.         EndM
  939.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  940.         IMPORT_CFM_FUNCTION SetSRsrcState
  941.     ENDIF
  942.  
  943. ;
  944. ; pascal OSErr InsertSRTRec(SpBlockPtr spBlkPtr)
  945. ;
  946.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  947.         ; parameters:
  948.         ;    spBlkPtr        => A0
  949.         ; returns:
  950.         ;    OSErr           <= D0
  951.         Macro
  952.         _InsertSRTRec
  953.             moveq               #10,D0
  954.             dc.w                $A06E
  955.         EndM
  956.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  957.         IMPORT_CFM_FUNCTION InsertSRTRec
  958.     ENDIF
  959.  
  960. ;
  961. ; pascal OSErr SGetSRsrc(SpBlockPtr spBlkPtr)
  962. ;
  963.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  964.         ; parameters:
  965.         ;    spBlkPtr        => A0
  966.         ; returns:
  967.         ;    OSErr           <= D0
  968.         Macro
  969.         _SGetSRsrc
  970.             moveq               #11,D0
  971.             dc.w                $A06E
  972.         EndM
  973.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  974.         IMPORT_CFM_FUNCTION SGetSRsrc
  975.     ENDIF
  976.  
  977. ;
  978. ; pascal OSErr SGetTypeSRsrc(SpBlockPtr spBlkPtr)
  979. ;
  980.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  981.         ; parameters:
  982.         ;    spBlkPtr        => A0
  983.         ; returns:
  984.         ;    OSErr           <= D0
  985.         Macro
  986.         _SGetTypeSRsrc
  987.             moveq               #12,D0
  988.             dc.w                $A06E
  989.         EndM
  990.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  991.         IMPORT_CFM_FUNCTION SGetTypeSRsrc
  992.     ENDIF
  993.  
  994. ;
  995. ; pascal OSErr SGetSRsrcPtr(SpBlockPtr spBlkPtr)
  996. ;
  997.     IF TARGET_OS_MAC ** TARGET_CPU_68K ** ¬ TARGET_RT_MAC_CFM THEN
  998.         ; parameters:
  999.         ;    spBlkPtr        => A0
  1000.         ; returns:
  1001.         ;    OSErr           <= D0
  1002.         Macro
  1003.         _SGetSRsrcPtr
  1004.             moveq               #29,D0
  1005.             dc.w                $A06E
  1006.         EndM
  1007.     ELSEIF TARGET_OS_MAC ** TARGET_RT_MAC_CFM THEN
  1008.         IMPORT_CFM_FUNCTION SGetSRsrcPtr
  1009.     ENDIF
  1010.  
  1011.  
  1012.  
  1013.     ENDIF ; __SLOTS__ 
  1014.  
  1015.